System for remotely controlling client recording and storage behavior

ABSTRACT

A system for remotely controlling client recording and storage behavior schedules the recording, storing, and deleting of multimedia content on a client system storage device. The viewer may request that certain content be captured. Capture requests also allow the service to determine content to be recorded by the client system in the same manner that a viewer requests that certain content are recorded but are more powerful than what a viewer can request. Recording requests for a capture request can preempt viewer requests or be entered at the same or lower priority as a viewer request. Capture requests can adjust all aspects of a recording request and affect the capture request itself. Client system operational functionality are also manipulated by the service using capture requests.

CROSS REFERENCE TO RELATED APPLICATIONS

This application is a continuation of U.S. patent application Ser. No.12/806,661, filed Aug. 16, 2010, which is a continuation of U.S. patentapplication Ser. No. 12/360,102, filed Jan. 26, 2009, now U.S. Pat. No.7,779,446, which is a continuation of U.S. patent application Ser. No.10/339,700, filed Jan. 8, 2003, now U.S. Pat. No. 7,543,325, whichclaims benefit of U.S. Provisional Patent Application Ser. No.60/347,181, filed on Jan. 8, 2002 and is a continuation-in-part of U.S.patent application Ser. No. 09/422,121, filed on Oct. 20, 1999, now U.S.Pat. No. 7,665,111, which claims benefit of U.S. Provisional PatentApplication Ser. No. 60/347,181, filed on Jan. 8, 2002, the entirecontents of which are incorporated herein by reference. The applicant(s)hereby rescind any disclaimer of claim scope in the parentapplication(s) or the prosecution history thereof and advise the USPTOthat the claims in this application may be broader than any claim in theparent application(s).

BACKGROUND OF THE INVENTION

1. Technical Field

The invention relates to controlling the storage and recording behaviorsof a client system. More particularly, the invention relates to remotelycontrolling the storage and recording behaviors of a client system froma server.

2. Description of the Prior Art

A classic tension exists in the design of automated data processingsystems between pure client-server based systems, such as computermainframe systems or the World Wide Web, and pure distributed systems,such as Networks of Workstations (NOWS) that are used to solve complexcomputer problems, such as modeling atomic blasts or breakingcryptographic keys.

Client-server systems are popular because they rely on a clean divisionof responsibility between the server and the client. The server is oftencostly and specially managed, since it performs computations or storesdata for a large number of clients. Each client is inexpensive, havingonly the local resources needed to interact with the user of the system.A network of reasonable performance is assumed to connect the server andthe client. The economic model of these systems is that of centralizedmanagement and control driving down the incremental cost of deployingclient systems.

However, this model has significant costs that must be considered. Forinstance, the incremental cost of adding a new client system may bequite high. Additional network capacity must be available, sufficientcomputing resources must be available to support that client, includingstorage, memory and computing cycles, and additional operationaloverhead is needed for each client because of these additionalresources. As the central servers become larger and more complex theybecome much less reliable. Finally, a system failure of the serverresults in all clients losing service.

Distributed systems are popular because the resources of the system aredistributed to each client, which enables more complex functionalitywithin the client. Access to programs or data is faster since they arelocated with the client, reducing load on the network itself. The systemis more reliable, since the failure of a node affects only it. Manycomputing tasks are easily broken down into portions that can beindependently calculated, and these portions are cheaply distributedamong the systems involved. This also reduces network bandwidthrequirements and limits the impact of a failed node.

On the other hand, a distributed system is more complex to administer,and it may be more difficult to diagnose and solve hardware or softwarefailures.

Television viewing may be modeled as a client-server system, but onewhere the server-to-client network path is for all intents and purposesof infinite speed, and where the client-to-server path is incoherent andunmanaged. This is a natural artifact of the broadcast nature oftelevision. The cost of adding another viewer is zero, and the servicedelivered is the same as that delivered to all other viewers.

There have been, and continue to be, many efforts to deliver televisionprogramming over computer networks, such as the Internet, or even over alocal cable television plant operating as a network. The point-to-pointnature of computer networks makes these efforts unwieldy and expensive,since additional resources are required for each additional viewer.Fully interactive television systems, where the viewer totally controlsvideo streaming bandwidth through a client settop device, have proveneven more uneconomical because dedication of server resources to eachclient quickly limits the size of the system that can be profitablybuilt and managed.

However, television viewers show a high degree of interest in choice andcontrol over television viewing. This interest results in the need forthe client system to effectively manage the memory demands of programmaterial that a viewer wants to record. Additionally, the management ofrecording desired program material is of equal importance to the memorymanagement task.

Many in-home consumer electronics devices already contain mass storage,with many more to come. The amount of storage available in these devicesis already staggering, and there is no end in sight to the “double eachyear” rule-of-thumb for disk drives. Other types of storage media arealso getting larger in storage capacity every year, including:CompactFlash, SmartMedia, Zip, Flash Memory Sticks, MicroDrive,PocketDrive, and SuperDisk.

The obvious control of this storage is by the viewer, storing his own TVshows, music, pictures, etc. on his client system. A less obvious use,but one that will continue to grow in application and importance, is aservice-provider's control of this storage. There will be a continuallygrowing desire for a service provider to have control over storage thatis physically possessed by the viewer.

It would be advantageous to provide a system for remotely controllingclient recording and storage behavior that allows a service provider toremotely control the storage behavior of a client system. It wouldfurther be advantageous to provide a system for remotely controllingclient recording and storage behavior that allows a service provider toremotely control the recording behavior of a client system.

SUMMARY OF THE INVENTION

The invention provides a system for remotely controlling clientrecording and storage behavior. The system allows a service provider toremotely control the storage behavior of a client system. In addition,the invention provides a system that allows a service provider toremotely control the recording behavior of a client system.

A client device, typified in U.S. Pat. No. 6,233,389, owned by theApplicant, provides functionality typically associated with centralvideo servers, such as storage of a large amount of video content,ability to choose and play this content on demand, and full “VCR-like”control of the delivery of the content, as typified in U.S. Pat. No.6,327,418, owned by the applicant.

A preferred embodiment of the invention schedules the recording,storing, and deleting of multimedia content on a client system storagedevice. The invention accepts as input a prioritized list of programviewing preferences which is compared with a database of program guideobjects. The program guide objects indicate when content of interest areactually broadcast.

A schedule of time versus available storage space is generated that isoptimal for the viewer's explicit or derived preferred content. Theviewer may request that certain content be captured, which results inthe highest possible priority for those content.

The viewer may also explicitly express preferences using appurtenancesprovided through the viewer interface. Preferences may additionally beinferred from viewing patterns. These preferences correspond to objectsstored in a replicated database.

The invention provides objects called a capture requests that are sentby the service to client systems. Capture requests reflect local storagemanagement decisions about how the client system storage is allocated(partitioned). The capture requests may be authored and changed overtime. Capture requests also allow the service to determine content to berecorded by the client system in the same manner that a viewer requeststhat certain content are recorded.

Capture requests are more powerful than what a viewer can request.Recording requests for a capture request can preempt viewer requests orbe entered at the same or lower priority as a viewer request. Capturerequests can adjust all aspects of a recording request and affect thecapture request itself. Client system operational functionality are alsomanipulated by the service using capture requests.

The invention correlates an input schedule that tracks the free andoccupied time slots for each input source with a space schedule thattracks all currently recorded content and the content that have beenscheduled to be recorded in the future, to schedule new content torecord and resolve recording conflicts. Content is recorded if at alltimes between when the recording would be initiated and when it expires,sufficient space is available to hold it. Content scheduled forrecording based on inferred preferences automatically lose all conflictdecisions. All scheduling conflicts are resolved as early as possible.Schedule conflicts resulting from the recording of aggregate objects areresolved using the preference weighting of the content involved.

A background scheduler attempts to schedule each preferred content inturn until the list of preferred content is exhausted or no furtheropportunity to record is available. A preferred content is scheduled ifand only if there are no conflicts with other scheduled content.

Other aspects and advantages of the invention will become apparent fromthe following detailed description in combination with the accompanyingdrawings, illustrating, by way of example, the principles of theinvention.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 is a block schematic diagram of a preferred embodiment of adistributed television viewing management system according to theinvention;

FIG. 2 is a block schematic diagram of the structure of a viewing objectin computer storage for programmatic access according to the invention;

FIG. 3 is a block schematic diagram showing how the schema for a viewingobject is structured in computer storage for programmatic accessaccording to the invention;

FIG. 4 is a block schematic diagram showing an example graph ofrelationships between viewing objects which describe information aboutprograms according to the invention;

FIG. 5 is a block schematic diagram showing an example graph ofrelationships generated when processing viewer preferences to determineprograms of interest according to the invention;

FIG. 6 is a block schematic diagram showing the scheduling of inputs andstorage space for making recordings according to the invention;

FIG. 7 is a flowchart showing the steps taken to schedule a recordingusing the mechanism depicted in FIG. 6 according to the invention;

FIG. 8 is a block schematic diagram of a preferred embodiment of theinvention showing the bootstrap system configuration according to theinvention;

FIG. 9 a is a block schematic diagram of the decision flowchart for thebootstrap component according to the invention;

FIG. 9 b is a block schematic diagram of the decision flowchart for thebootstrap component according to the invention;

FIG. 10 is a block schematic diagram of the decision flowchart for thesoftware installation procedure according to the invention;

FIG. 11 is a block schematic diagram of a preferred embodiment of theinvention distributing content information to a plurality of clientsystems that record content from a broadcast signal based on remotecommands from a server according to the invention; and

FIG. 12 is a block schematic diagram showing an authoring anddistribution system for controlling a client system's storage andrecording behavior according to the invention.

DETAILED DESCRIPTION OF THE INVENTION

The invention is embodied in a system for remotely controlling clientrecording and storage behavior. A system according to the inventionallows a service provider to remotely control the storage behavior of aclient system. In addition, the invention allows a service provider toremotely control the recording behavior of a client system.

The invention is embodied in a television viewing informationtransmission and collection system that improves the ability of theindividual viewer to select and automatically timeshift televisionprograms while providing opportunities for a service provider to enhanceand direct the viewing experience. The invention describes a systemwhich is fully distributed, in that calculations pertaining to anindividual viewer are performed personally for that viewer within alocal client device, while providing for the reliable aggregation anddissemination of information concerning viewing habits, preferences orpurchases.

The Database of Television Viewing Information

FIG. 1 gives a schematic overview of the invention. Central to theinvention is a method and apparatus for maintaining a distributeddatabase of television viewing information among computer systems at acentral site 100 and an extremely large number of client computingsystems 101. The process of extracting suitable subsets of the centralcopy of the database is called “slicing” 102, delivering the resulting“slices” to clients is called “transmission” 103, delivering informationcollected about or on behalf of the viewer to the central site is called“collection” 104, and processing the collected information to generatenew television viewing objects or reports is called “analysis” 107; inall cases, the act of recreating an object from one database withinanother is called “replication” 105. Data items to be transmitted orcollected are termed “objects” 106, and the central database and eachreplicated subset of the central database contained within a clientdevice is an “object-based” database. The objects within this databaseare often termed “television viewing objects”, “viewing objects”, orsimply “objects”, emphasizing their intended use. However, one skilledin the art will readily appreciate that objects can be any type of data.

The viewing object database provides a consistent abstract softwareaccess model for the objects it contains, independent of and in parallelwith the replication activities described herein. By using thisinterface, applications may create, destroy, read, write and otherwisemanipulate objects in the database without concern for underlyingactivities and with assurance that a consistent and reliable view of theobjects in the database and the relationships between them is alwaysmaintained.

Basic Television Viewing Object Principles

Referring to FIG. 2, television viewing objects are structured as acollection of “attributes” 200. Each attribute has a type 201, e.g.,integer, string or boolean, and a value 202. All attribute types aredrawn from a fixed pool of basic types supported by the database.

The attributes of an object fall into two groups: “basic” attributes,which are supplied by the creator or maintainer of the viewing object;and “derived” attributes, which are automatically created and maintainedby mechanisms within the database. Basic attributes describe propertiesof the object itself; derived attributes describe the relationshipsbetween objects. Basic attributes are replicated between databases,whereas derived attributes are not.

With respect to FIG. 3, there is a small set of fundamental object typesdefined by the invention; each object type is represented as a specificset of related attributes 300, herein called a “schema”. The schemadefines a template for each attribute type 301, which includes the type302 and name of the attribute 303. Actual television viewing objects arecreated by allocating resources for the object and assigning values tothe attributes defined by the schema. For example, a “program” schemamight include attributes such as the producer, director or actors in theprogram, an on-screen icon, a multi-line description of the programcontents, an editorial rating of the program, etc. A physical programobject is created by allocating storage for it, and filling in theattributes with relevant data.

There is one special object type predefined for all databases called theschema type. Each schema supported by the database is represented by aschema object. This allows an application to perform “introspection” onthe database, i.e., to dynamically discover what object types aresupported and their schema. This greatly simplifies application softwareand avoids the need to change application software when schemas arechanged, added or deleted. Schema objects are handled the same as allother viewing objects under the methods of this invention.

Referring again to FIG. 2, each object in a database is assigned an“object ID” 203 which must be unique within the database. This object IDmay take many forms, as long as each object ID is unique. The preferredembodiment uses a 32-bit integer for the object ID, as it provides auseful tradeoff between processing speed and number of unique objectsallowed. Each object also includes a “reference count” 204, which is aninteger giving the number of other objects in the database which referto the current object. An object with a reference count of zero will notpersist in the database (see below).

One specific type of viewing object is the “directory” object. Adirectory object maintains a list of object IDs and an associated simplename for the object. Directory objects may include other directoryobjects as part of the list, and there is a single distinguished objectcalled the “root” directory. The sequence of directory objects traversedstarting at the root directory and continuing until the object ofinterest is found is called a “path” to the object; the path thusindicates a particular location within the hierarchical namespacecreated among all directory objects present in the database. An objectmay be referred to by multiple paths, meaning that one object may havemany names. The reference count on a viewing object is incremented byone for each directory which refers to it.

Methods for the Maintenance of Database Consistency and Accuracy

One of the features of a preferred embodiment of the invention is toinsure that each database replica remains internally consistent at alltimes, and that this consistency is automatically maintained withoutreference to other databases or the need for connection to the centralsite. There is no assurance that transmission or collection operationshappen in a timely manner or with any assured periodicity. For instance,a client system may be shut off for many months; when a transmission tothe system is finally possible, the replication of objects must alwaysresult in a consistent subset of the server database, even if it is notpossible to transmit all objects needed to bring the central and clientdatabases into complete synchronization.

Even more serious, there can be no guarantee of a stable operationalenvironment while the database is in use or being updated. For example,electrical power to the device may cease. This invention treats alldatabase updates as “transactions”, meaning that the entire transactionwill be completed, or none of it will be completed. The specifictechnique chosen is called “two-phase commit”, wherein all elements ofthe transaction are examined and logged, followed by performing theactual update. One familiar in the art will appreciate that a standardjournaling technique, where the transaction is staged to a separate log,combined with a roll-forward technique which uses the log to repeatpartial updates that were in progress when the failure occurred, issufficient for this purpose.

One required derived attribute of every object is the “version”, whichchanges with each change to the object; the version attribute may berepresented as a monotonically increasing integer or otherrepresentation that creates a monotonic ordering of versions. The schemafor each object that may be replicated includes an attribute called“source version” which indicates the version of the object from whichthis one was replicated.

Transmission of a viewing object does not guarantee that every clientreceives that object. For instance, while the object is being broadcast,external factors such as sunspots, may destroy portions of thetransmission sequence. Viewing objects may be continually retransmittedto overcome these problems, meaning that the same object may bepresented for replication multiple times. It is inappropriate to simplyupdate the database object each time an object to be replicated isreceived, as the version number will be incremented although no changehas actually occurred. Additionally, it is desirable to avoid initiatinga transaction to update an object if it is unnecessary; considerablesystem resources are consumed during a transaction.

Two approaches are combined to resolve this problem. First, most objectswill have a basic attribute called “expiration”. This is a date and timepast which the object is no longer valid, and should be discarded. Whena new object is received, the expiration time is checked, and the objectdiscarded if it has expired. Expiration handles objects whosetransmission is delayed in some fashion, but it does not handle multiplereceptions of the same unexpired object.

The source version attribute handles this problem. When a viewing objectis transmitted, this attribute is copied from the current versionattribute of the source object. When the viewing object is received, thesource version of the received object is compared with the sourceversion of the current object. If the new object has a higher sourceversion attribute, it is copied over the existing object, otherwise itis discarded.

It is assumed that a much greater number of viewing objects aretransmitted than are of interest to any particular client system. Forexample, a “channel” viewing object which describes the channels on aparticular cable system is of no interest to clients attached to othercable systems. Because of the overhead of capturing and adding newobjects to the database, it would be advantageous for received objectsto be filtered on other attributes in addition to those described above.The invention accomplishes this by using a filtering process based onobject type and attribute values. In one implementation, this filteringprocess is based on running executable code of some kind, perhaps as asequence of commands, which has been written with specific knowledge ofvarious object types and how they should be filtered.

In a preferred embodiment of the invention, a “filter” object is definedfor each object type which indicates what attributes are required,should not be present, or ranges of values for attributes that make itacceptable for addition to the database. One skilled in the art willreadily appreciate that this filter object may contain executable codein some form, perhaps as a sequence of executable commands. Thesecommands would examine and compare attributes and attribute values ofobject being filtered, resulting in an indication of whether the objectshould be the subject of further processing.

Viewing objects are rarely independent of other objects. For example, a“showing” object (describing a specific time on a specific channel) isdependent on a “program” object (describing a specific TV program). Oneimportant aspect of maintaining consistency is to insure that alldependent objects either already exist in the database or are to beadded as part of a single transaction before attempting to add a newviewing object. This is accomplished using a basic attribute of the newviewing object called the “dependency” attribute, which simply lists theobject IDs and source versions of objects that the new object isdependent on. Clearly, new versions of an object must be compatible, inthe sense that the schema defining new versions be the same or have astrict superset of the attributes of the original schema.

When a new viewing object is received, the database is first checked tosee if all dependencies of that object are present; if so, the object isadded to the database. Otherwise, the new object is “staged”, saving itin a holding area until all dependent objects are also staged. Clearly,in order for a new set of viewing objects to be added to the database,the dependency graph must be closed between objects in the staging areaand objects already existing in the database, based on both object IDand source version. Once closure is achieved, meaning all dependentobjects are present, the new object(s) are added to the database in asingle atomic transaction.

Naming and Finding Television Viewing Objects

Directory objects have been described previously. Referring to FIG. 4,the collection of directory objects, and the directed graph formed bystarting at the root path 400 and enumerating all possible paths toviewing objects is called a “namespace”. In order for an object to befound without knowing a specific object ID, one or more paths withinthis namespace must refer to it. For instance, application software haslittle interest in object IDs, instead the software would like to referto objects by paths, for instance “/tvschedule/today”. In this example,the actual object referred to may change every day, without requiringchanges in any other part of the system.

One way in which a path to an object may be established is by specifyinga “pathname” basic attribute on the object. The object is added to thedatabase, and directory objects describing the components of the pathare created or updated to add the object. Such naming is typically usedonly for debugging the replication mechanisms. Setting explicit paths isdiscouraged, since the portions of the central database replicated oneach client system will be different, leading to great difficulty inmanaging pathnames among all replicas of the database.

A preferred method for adding an object to the database namespace iscalled “indexing”. In a preferred embodiment of the invention, an“indexer” object is defined for each object type which indicates whatattributes are to be used when indexing it into the database namespace.One skilled in the art will readily appreciate that this indexer objectmay contain executable code in some form, perhaps as a sequence ofexecutable commands. These commands would examine and compare attributesand attribute values of object being indexed, resulting in an indicationof where the object should be located in the namespace.

Based on the object type, the indexer examines a specific set ofattributes attached to the object. When such attributes are discoveredthe indexer automatically adds a name for the object, based on the valueof the attribute, within the hierarchical namespace represented by thegraph of directories in the database. Referring again to FIG. 4, aprogram object may have both an “actor” attribute with value “JohnWayne” and a “director” attribute with value “John Ford” 401. The rootdirectory might indicate two sub-directories, “byactor” 402 and“bydirector” 403. The indexer would then add the paths “/byactor/JohnWayne” and “/bydirector/John Ford” to the database, both of which referto the same object 401.

A derived attribute is maintained for each object listing the directoryobjects which refer to this object 404. As the indexer adds paths to thenamespace for this object, it adds the final directory ID in the path tothis list. This insures closure of the object graph—once the object hasbeen found, all references to that object within the database are alsofound, whether they are paths or dependencies.

This unique and novel method of adding objects to the database hassignificant advantages over standard approaches. The indexer sorts theobject into the database when it is added. Thus, the search for theobject associated with a particular path is a sequence of selectionsfrom ordered lists, which can be efficiently implemented by one familiarwith the art.

Deleting Objects from the Database

While the rules for adding objects to the database are important, therules for removing objects from the database are also important inmaintaining consistency and accuracy. For example, if there were norobust rules for removing objects, the database might grow unboundedlyover time as obsolete objects accumulate.

The cardinal rule for deleting objects from the database is based onreference counting; an object whose reference count drops to zero issummarily deleted. For instance, this means that an object must eitherbe referred to by a directory or some other object to persist in thedatabase. This rule is applied to all objects in the closed dependencygraph based on the object being deleted. Thus, if an object which refersto other objects (such as a directory) is deleted, then the referencecount on all objects referred to is decremented, and those objectssimilarly deleted on a zero count, and so forth.

There is also an automatic process which deletes objects from thedatabase called the “reaper”. Periodically, the reaper examines allobjects in the database, and depending on the object type, furtherexamines various attributes and attribute values to decide if the objectshould be retained in the database. For example, the expirationattribute may indicate that the object is no longer valid, and thereaper will delete the object.

In the preferred embodiment, using a method similar to (or perhapsidentical to) the filtering and indexing methods described above, thereaper may instead access a reaper object associated with the objecttype of the current object, which may contain executable code of variouskinds, perhaps a sequence of executable commands. This code examines theattributes and attribute values of the current object, and determines ifthe object should be deleted.

The overhead of individually deleting every object for which thereference count has been decremented to zero may be quite high, sinceevery such deletion results in a transaction with the database. It wouldbe advantageous to limit the performance impact of reaping objects, suchthat foreground operations proceed with maximum speed. In a preferredembodiment, this is accomplished using a technique based on commongarbage collection methods.

For instance, instead of deleting an object whose reference count hasbeen decremented to zero, the reaper performs no other action.Periodically, a background task called the garbage collector examineseach object in the database. If the object has a reference count ofzero, it is added to a list of objects to be deleted. In one embodiment,once the garbage collector has examined the entire database, it woulddelete all such objects in a single transaction. One familiar in the artwill appreciate that this method may also result in a significantperformance penalty, as other accesses to the database may be delayedwhile the objects are being deleted. In addition, if all objects are tobe properly deleted, changes to the database may have to be delayedwhile the garbage collector is active, resulting in even worseperformance.

In a preferred embodiment, the garbage collector examines the databasein a series of passes. Once a specific number of objects has beencollected, they are deleted in a single transaction. Said processcontinues until all objects have been examined. This technique does notguarantee that all garbage objects are collected during the examinationprocess, since parallel activities may release objects previouslyexamined. These objects will be found, however, the next time thegarbage collector runs. The number of objects deleted in each pass isadjustable to achieve acceptable performance for other databaseactivities.

Operations on the Distributed Television Viewing Object Database

Considerations in Maintaining the Distributed Viewing Object Database

The replication of television viewing objects among the instances of thedistributed database necessarily requires the transmission of objectsover unreliable and unsecure distribution channels.

For example, if the objects are transmitted over a broadcast mechanism,such as within a radio or television transmission, there can be noassurance that the data is transmitted accurately or completely.Weather, such as rainstorms, may cause dropouts in the transmission.Other sources of interference may be other broadcast signals, heavyequipment, household appliances, etc.

One skilled in the art will readily appreciate that there are standardtechniques for managing the transmission of data over unreliablechannels, including repeated transmissions, error correcting codes, andothers, which may be used for transmission, any or all of which may beused in any particular instance.

For efficiency, objects to be replicated are gathered together intodistribution packages, herein called “slices”. A slice is a subset ofthe television viewing object database which is relevant to clientswithin a specific domain, such as a geographic region, or under thefootprint of a satellite transmitter.

Security of these slices is quite important. Slices are used to addobjects to the database which are used to provide valuable services tousers of the database, as well as to store information that may beconsidered private or secret. Because of the broadcast-oriented natureof slice transmission, slices may be easily copied by third parties asthey are transmitted. A practical solution to these problems is toencrypt the slice during transmission. An ideal reference text on thetechniques employed in the invention is “Applied Cryptography:Protocols, Algorithms, and Source Code in C” by Bruce Schneier, JohnWiley and Sons, 1995.

In a preferred embodiment of the invention, a secure, encrypted channelis established using techniques similar to those described in U.S. Pat.No. 4,405,829, often described as asymmetric key encryption, orsometimes public/private key pair encryption. A practitioner skilled inthe art will recognize that protocols based on asymmetric key encryptionserves as a reliable and efficient foundation for authentication ofclient devices and secure distribution of information. In general,authentication is provided using an exchange of signed messages betweenthe client and central systems. Secure distribution is provided byencrypting all communications using a short-lived symmetric key sentduring an authentication phase.

Successful security requires that sender and receiver agree beforehandon the asymmetric key pair to be used for encryption. Such keydistribution is the weakest link in any cryptographic system forprotecting electronic data. U.S. Pat. No. 6,385,739, entitled “Self-TestElectronic Assembly and Test System,” filed Jul. 19, 1999, also owned bythe Applicant, describes a mechanism whereby the client device generatesthe asymmetric key pair automatically as the final step in themanufacturing process. The private key thus generated is stored within asecure microprocessor embedded within the client device, such that thekey is never presented to external devices. The public key thusgenerated is transmitted to a local manufacturing system, which recordsthe key along with the client serial number in a secure database. Thisdatabase is later securely transmitted to the central distributionsystem, where it is used to perform secure communications with theclient.

This unique and novel application of key generation solves the problemof key distribution, as the private key is never presented to externalcomponents in the client, where it might be discerned using specialtools, such as a logic analyzer. Instead, it may only be used within thesecurity microprocessor itself to decrypt messages originally encryptedwith the public key, the results of which are then provided to externalcomponents.

The remainder of this discussion assumes that all communications betweenclient and central systems are authenticated and encrypted as describedabove.

Transmitting Viewing Objects to the Client Systems

Referring again to FIG. 1, in a preferred embodiment of the inventionthe following steps constitute “transmission” of television viewingobjects from the central database using slices:

-   1. There may be many mechanisms for transmitting slices to the    universe of client viewing devices. For instance, the slices may be    directly downloaded over a telephone modem or cable modem 109, they    may be modulated into lines of the Vertical Blanking Interval (VBI)    of a standard television broadcast 108, or added to a digital    television multiplex signal as a private data channel. One skilled    in the art will readily appreciate that any mechanism which can    transmit digital information may be used to transmit slices of the    television viewing object database.-    The first step in preparing television viewing objects for    transmission is recognizing the transmission mechanism to be used    for this particular instance, and creating a slice of a subset of    the database that is customized for that mechanism. For example, the    database may contain television viewing objects relating to all    programs in the country. However, if television viewing objects are    to be sent using VBI modulation on a local television signal, only    those television viewing objects relating to programs viewable    within the footprint of the television broadcast being used to carry    them should be contained within the relevant slice. Alternatively,    if some of the television viewing objects contain promotional    material related to a particular geographic region, those objects    should not be transmitted to other geographic regions.-    In a preferred embodiment of the invention, the speed and    periodicity of traversing the database and generating slices for    transmission is adjustable in an arbitrary fashion to allow useful    cost/performance tradeoffs to be made. For instance, it may only be    necessary to create slices for certain transmission methods every    other day, or every hour.-    The final step in preparing each slice is to encrypt the slice    using a short-lived symmetric key. Only client devices which have    been authenticated using secure protocols will have a copy of this    symmetric key, making them able to decrypt the slice and access the    television viewing objects within it.-   2. Once a slice is complete, it is copied to the point at which the    transmission mechanism can take and send the data 110. For telephone    connections, the slice is placed on a telephony server 111 which    provides the data to each client as it calls in. If television    broadcast is used, the slice is copied onto equipment co-resident    with the station television transmitter, from whence it is modulated    onto the signal. In these and similar broadcast-oriented cases, the    slice is “carouseled”, i.e., the data describing the slice is    repeated continually until a new slice is provided for transmission.-    This repetitive broadcast of slices is required because there can    be no assurance that the signal carrying the data arrives reliably    at each client. The client device may be powered off, or there may    be interference with reception of the signal. In order to achieve a    high degree of probability that the transmitted slices are properly    received at all client devices, they are continually re-broadcast    until updated slices are available for transmission.-    A preferred embodiment of the invention uses broadcast mechanisms    such as a television signal to transmit the slice. However, it is    desirable to provide for download over a connection-based mechanism,    such as a modem or Internet connection. Using a connection-based    mechanism usually results in time-based usage fees, making it    desirable to minimize the time spent transmitting the slice.-    This is accomplished using a two-step process. When the connection    is established, the client system sends an inventory of previously    received slices to telephony servers 111. The server compares this    inventory with the list of slices that should have been processed by    that client. Slices which were not processed are transmitted to the    client system.-   3. The slice is transmitted by breaking the encrypted slice into a    succession of short numbered data packets. These packets are    captured by client systems and held in a staging area until all    packets in the sequence are present. The packets are reassembled    into the slice, which is then decrypted. The television viewing    objects within the slice are then filtered for applicability,    possibly being added to the local television viewing object    database. This process replicates a portion of the central database    of television viewing objects reliably into the client.-    The invention keeps track of the time at which data packets are    received. Data packets which are older than a selected time period    are purged from the staging area on a periodic basis; this avoids    consuming space for an indefinite period while waiting for all parts    of a slice to be transmitted.-    Especially when transmitting the objects over a broadcast medium,    errors of various kinds may occur in the transmitted data. Each data    packet is stamped with an error detecting code (a parity field or    CRC code, for example). When an error is detected the data packet is    simply discarded. The broadcast carousel will eventually retransmit    the data packet, which is likely to be received properly. Slices of    any size may thus be sent reliably; this is achieved at the cost of    staging received portions of the object on the client until all    portions are properly received.-   4. There may be one or more “special” slices transmitted which    communicate service related data to the client system, particularly    service authorization information. It is important that the service    provider be able to control the client system's access to premium    services if the viewer has failed to pay his bill or for other    operational reasons.-    One particular type of special slice contains an “authorization”    object. Authorization objects are generally encrypted using    asymmetric key encryption based on the public/private key pair    associated with a specific client. If the slice can be successfully    decrypted by the security microprocessor using the embedded private    key, the slice will contain an object indicating the allowable time    delay before another authorization object is received, as well as    one or more symmetric keys valid for a short time period. The delay    value is used to reset a timestamp in the database indicating when    the client system will stop providing services. The symmetric keys    are stored in the local television viewing object database, to be    used in decrypting new slices which may be received.-    If the client has not received a proper authentication object by    the time set in the database, it will commence denial of most    services to the viewer (as specified by the service provider). Also    contained within an authentication object are one or more    limited-lifetime download keys which are needed to decrypt the    slices that are transmitted. Clearly, if a client system is unable    to authenticate itself, it will not be able to decrypt any objects.-    Each authorization slice is individually generated and transmitted.    If broadcast transmission is used for the slices, all relevant    authorizations are treated identically to all other slices and    carouseled along with all other data. If direct transmission is    used, such as via a phone connection, only the authentication slice    for that client is transmitted.-   5. Once the client device has received a complete database slice, it    uses the methods described earlier to add the new object contained    within it to the database.    Collecting Information from the Client Systems

Referring again to FIG. 1, in a preferred embodiment of the inventionthe following steps constitute “collection” of television viewingobjects from each client database:

-   1. As the viewer navigates the television channels available to him,    the client system records interesting information, such as channel    tuned to, time of tuning, duration of stay, VCR-like actions (e.g.,    pause, rewind), and other interesting information. This data is    stored in a local television viewing object.-    Additionally, the viewer may indicate interest in offers or    promotions that are made available, or he may indicate a desire to    purchase an item. This information is also recorded into a local    television viewing object.-    Additionally, operation of the client device may result in    important data that should be recorded into a television viewing    object. For example, errors may occur when reading from the hard    disk drive in the client, or the internal temperature of the device    may exceed operational parameters. Other similar types of    information might be failure to properly download an object, running    out of space for various disk-based operations, or rapid power    cycling.-   2. At a certain time, which may be immediate or on a periodic basis,    the client system contacts the central site via a direct connection    104 (normally via phone and/or an Internet connection). The client    device sends a byte sequence identifying itself which is encrypted    with its secret key. The server fetches the matching television    viewing object for the client device from the database, and uses the    key stored there to decrypt the byte sequence. At the same time, the    server sends a byte sequence to the client, encrypted in its secret    key, giving the client a new one-time encryption key for the    session.-    Both sides must successfully decrypt their authentication message    in order to communicate. This two-way handshake is important, since    it assures both client and server that the other is valid. Such    authentication is necessary to avoid various attacks that may occur    on the client system. For example, if communications were not    authenticated in such a fashion, a malicious party might create an    “alias” central site with a corrupt television viewing object    database and provide bad information to a client system, causing    improper operation. All further communication is encrypted using the    one-time session key. Encrypted communication is necessary because    the information may pass across a network, such as the Internet,    where data traffic is open to inspection by all equipment it passes    through. Viewing objects being collected may contain information    that is considered private, so this information must be fully    protected at all times.-    Assuming that the authentication phase is successful, the two    parties treat the full-duplex phone line as two one-way broadcast    channels. New slices are delivered to the client, and viewing data    to be collected is sent back. The connection is ended when all data    is delivered.-    One skilled in the art will readily appreciate that this connection    may take place over a network, such as the Internet running standard    TCP/IP protocols, transparently to all other software in the system.-   3. Uploaded information is handled similarly by the server; it is    assumed to represent television viewing objects to be replicated    into the central database. However, there may be many uploaded    viewing objects, as there may be many clients of the service.    Uploaded objects are therefore assigned a navigable attribute    containing information about their source; the object is then    indexed uniquely into the database namespace when it is added.-    Uploaded viewing objects are not immediately added to the central    database; instead they are queued for later insertion into the    database. This step allows the processing of the queue to be    independent of the connection pattern of client devices. For    instance, many devices may connect at once, generating a large    number of objects. If these objects were immediately added to the    central database, the performance of all connections would suffer,    and the connection time would increase. Phone calls are charged by    duration, thus any system in which connection time increases as a    function of load is not acceptable.-    Another advantage of this separation is that machine or network    failures are easily tolerated. In addition, the speed at which    viewing objects are processed and added to the central database may    be controlled by the service provider by varying the computer    systems and their configurations to meet cost or performance goals.-    Yet another advantage of this separation is that it provides a    mechanism for separating data collected to improve service    operations and data which might identify an individual viewer. It is    important that such identifying data be kept private, both for legal    reasons and to increase the trust individuals have in the service.    For instance, the navigable attribute assigned to a viewing object    containing the record of a viewer's viewing choices may contain only    the viewer's zip code, meaning that further processing of those    objects can construct no path back to the individual identity.-    Periodic tasks are invoked on the server to cull these objects from    the database and dispose of them as appropriate. For example,    objects indicating viewer behavior are aggregated into an overall    viewer behavior model, and information that might identify an    individual viewer is discarded. Objects containing operational    information are forwarded to an analysis task, which may cause    customer service personnel to be alerted to potential problems.    Objects containing transactional information are forwarded to    transaction or commerce systems for fulfillment.-    Any of these activities may result in new television viewing    objects being added to the central database, or in existing objects    being updated. These objects will eventually be transmitted to    client devices. Thus, the television viewing management system is    closed loop, creating a self-maintaining replicated database system    105 which can support any number of client systems.    Processing of Television Viewing Objects by Client Systems

Television viewing objects may contain the following types ofinformation: television program descriptions and showing times; cable,satellite or broadcast signal originator information, such as channelnumbering and identification; viewer preference information, such asactors, genre, showing times, etc.; software, such as enhanced databasesoftware, application software, operating system software, etc.;statistical modeling information such as preference vectors, demographicanalysis, etc.; and any other arbitrary information that may berepresented as digital data.

Methods Applied to Program Guide Objects

Program guide objects contain all information necessary for softwarerunning in the client system to tune, receive, record and view programsof interest to the user of the client system, selecting from among allavailable programs and channels as described by objects within thedatabase.

This program guide information is updated on a regular basis by aservice provider. This is handled by the provider acquiring programguide information in some manner, for instance, from a commercialsupplier of such information or other sources of broadcast scheduleinformation. This data is then processed using well-understood softwaretechniques to reduce the information to a collection of inter-relatedviewing objects.

Referring again to FIG. 4, a typical relationship between program guideobjects is shown. A television “network” object 407 is any entity whichschedules and broadcasts television programming, whether that broadcastoccurs over the air, cable, satellite, or other suitable medium. Atelevision “program” object 401 is a description of any distinct segmentof a television broadcast signal, such as a particular program,commercial advertisement, station promotion, opener, trailer, or anyother bounded portion of a television signal. A “showing” object 406 isa portion of the broadcast schedule for a network on which a program isbroadcast. A “channel map” object maps a network broadcast onto aparticular broadcast channel for the medium being used; for instance, achannel map object for a satellite broadcast service would includeinformation about the transponder and data stream containing thebroadcast. Using the previously described methods, this program guidedata is replicated from the central site to the client systems, whereapplication software in the client systems use the data to managetelevision viewing.

The service provider may also provide aggregation viewing objects, whichdescribe a set of program guide objects that are interrelated in somefashion. For instance, a “Star-Trek” collection might contain referencesto all program guide objects associated with this brand name. Clearly,any arbitrary set of programs may be aggregated in this fashion.Aggregation objects are similar to directories. For instance, the StarTrek collection might be found at “/showcases/Star Trek” in thehierarchical namespace. Aggregation objects are also program guideobjects, and may be manipulated in a similar fashion, includingaggregating aggregation objects, and so forth.

The client system may further refine the collection of program objects.In a system where programming may be captured to internal storage, eachcaptured program is represented by a new program guide object, becomingavailable for viewing, aggregation, etc. Explicit viewer actions mayalso result in creation of program guide objects. For instance, theviewer may select several programs and cause creation of a newaggregation object.

This description of types of program guide objects is not meant to beinclusive; there may be many different uses and ways of generatingprogram guide objects not herein described which still benefit from thefundamental methods of the invention.

Program guide objects are used by the application software in five ways:

-   1. In the simplest case, the viewer may wish to browse these objects    to discern current or soon-to-be-available programming. The    application software will map the object relationships described by    the database to some form of visual and audible interface that is    convenient and useful for the viewer. The viewer may indicate that a    particular program is of interest, resulting in some    application-specific action, such as recording the program to local    storage when it is broadcast.-   2. Application software may also directly process program guide    objects to choose programs that may be of interest to the viewer.    This process is typically based on an analysis of previously watched    programming combined with statistical models, resulting in a    priority ordering of all programs available. The highest priority    programs may be processed in an application specific manner, such as    recording the program to local storage when it is broadcast.    Portions of the priority ordering so developed may be presented to    the viewer for additional selection as in case 1.-    One skilled in the art will readily appreciate that there is a    great deal of prior art centered on methods for selecting    programming for a viewer based on previous viewing history and    explicit preferences, e.g., U.S. Pat. No. 5,758,257. The methods    described in this application are unique and novel over these    techniques as they suggest priorities for the capture of    programming, not the broadcast or transmission of programming, and    there is no time constraint on when the programming may be    broadcast. Further details on these methods are given later in this    description.-    In general, explicit viewer choices of programming have the highest    priority for capture, followed by programming chosen using the    preference techniques described herein.-   3. A client system will have a small number of inputs capable of    receiving television broadcasts or accessing Web pages across a    network such as an intranet or the Internet. A scheduling method is    used to choose how each input is tuned, and what is done with the    resulting captured television signal or Web page.-    Referring to FIG. 6, generally, the programs of interest to the    viewer may be broadcast at any time, on any channel, as described by    the program guide objects. Additionally, the programs of interest    may be Web page Universal Resource Locators (URL) across a network,    such as an intranet or the Internet. The channel metaphor is used to    also describe the location, or URL, of a particular Web site or    page.-    A viewer, for example, can “tune” into a Web site by designating    the Web site URL as a channel. Whenever that channel is selected,    the Web site is displayed. A Web page may also be designated as a    program of interest and a snapshot of the Web page will be taken and    recorded at a predetermined time.-    The scheduler accepts as input a prioritized list of program    viewing preferences 603, possibly generated as per the cases above.    The scheduling method 601 then compares this list with the database    of program guide objects 604, which indicate when programs of    interest are actually broadcast. It then generates a schedule of    time 607 versus available storage space 606 that is optimal for the    viewer's explicit or derived preferred programs. Further details on    these methods are given later in this description.-   4. When a captured program is viewed, the matching program guide    object is used to provide additional information about the program,    overlaid on the display using any suitable technique, preferably an    On Screen Display (OSD) of some form. Such information may include,    but is not limited to: program name; time, channel or network of    original broadcast; expiration time; running time or other    information.-   5. When live programming is viewed, the application uses the current    time, channel, and channel map to find the matching program guide    object. Information from this object is displayed using any suitable    technique as described above. The information may be displayed    automatically when the viewer changes channels, when a new program    begins, on resumption of the program after a commercial break, on    demand by the viewer, or based on other conditions.-   6. Using techniques similar to those described in case 2,    application software may also capture promotional material that may    be of interest to the viewer. This information may be presented on    viewer demand, or it may be automatically inserted into the output    television signal at some convenient point. For example, an    advertisement in the broadcast program might be replaced by a    different advertisement which has a higher preference priority.    Using the time-warping apparatus, such as that described in U.S.    Pat. No. 6,233,389, entitled “Multimedia Time Warping System,” filed    Jul. 30, 1998, it is possible to insert any stored program into the    output television signal at any point. The time-warping apparatus    allows the overlaid program to be delayed while the stored program    is inserted to make this work.    Methods for Generating a List of Preferred Programs

Viewer preferences may be obtained in a number of ways. The viewer mayrequest that certain programs be captured, which results in the highestpossible priority for those programs. Alternatively, the viewer mayexplicitly express preferences using appurtenances provided through theviewer interface, perhaps in response to a promotional spot for aparticular program, or even during the viewing of a program Finally,preferences may be inferred from viewing patterns: programs watched,commercial advertisements viewed or skipped, etc.

In each case, such preferences must correspond to television viewingobjects stored in the replicated database. Program objects included awealth of information about each particular program, for example: title,description, director, producer, actors, rating, etc. These elements arestored as attributes attached to a program object.

Each individual attribute may result in the generation of a preferenceobject. Such objects store the following information:

-   1. The type of the preference item, such as actor or director    preference;-   2. The weight of the preference given by the viewer, which might be    indicated by multiple button presses or other means;-   3. The statically assigned significance of the preference in    relation to other preferences, for example, actor preference are    more significant than director preferences;-   4. The actual value of the preference item, for instance the name of    the director.

With respect to FIG. 5, preference objects are stored in the database asa hierarchy similar to that described for program guide objects, howeverthis hierarchy is built incrementally as preferences are expressed 500.The hierarchy thus constructed is based on “direct” preferences, e.g.,those derived from viewer actions or inferred preferences.

A similar hierarchy is developed based on “indirect” preferencespointing to the same preference objects 501. In general, indirectpreferences are generated when preferences for aggregate objects aregenerated, and are used to further weight the direct preferences impliedby the collection of aggregated objects. The preference objectsreferenced through the indirect preference hierarchy are generated orupdated by enumerating the available program objects which are part ofthe aggregate object 502, and generating or updating preference objectsfor each attribute thus found.

The weight of a particular preference 503 begins at zero, and then astandard value is added based on the degree of preference expressed(perhaps by multiple button presses) or a standard value is subtractedif disinterest has been expressed. If a preference is expressed based onan aggregate viewing object, all preferences generated by all viewingobjects subordinate to the aggregated object are similarly weighted.Therefore, a new weighting of relevant preference elements is generatedfrom the previous weighting. This process is bounded by the degree ofpreference which is allowed to be expressed, thus all weightings fallinto a bounded range.

In a preferred embodiment of the invention, non-linear combinations maybe used for weighting a preference item. For instance, using statisticalmodels provided by the central site, the client may infer that a heavilyweighted preference for three attributes in conjunction indicates that afourth attribute should be heavily weighted as well.

The list of preferred programs is generated as follows:

-   1. A table 504 is constructed which lists each possible program    object attribute, and any preference objects for that attribute that    are present are listed in that entry.-   2. If the preference item is a string, such as an actor name, a    32-bit digital signature for that string is calculated using a    32-bit CRC algorithm and stored with the table item, rather than the    string itself. This allows for much faster scanning of the table as    string comparisons are avoided, at the slight risk of two different    strings generating the same digital signature.-   3. For each program object in the database, and for each attribute    of that program, the attribute is looked up in the table. If    present, the list of preference objects for that attribute is    examined for a match with the attribute of the current program    object. If a match occurs, the weight associated with that    preference object is added to weighting associated with the program    object to generate a single weight for the program.-   4. Finally, the program objects are rank-ordered based on the    overall weighting for each program, resulting in a list of    most-preferred to least-preferred programs.

Given this final prioritized list, a recording schedule is generatedusing the methods described below, resulting in a collection of recordedprograms of most interest to the viewer.

Methods Applied to Scheduling Recording Versus Available Storage Space

As has been described previously, recorded programs will in general havean expiration date, after which the recorded program is removed fromclient storage. The viewer may at any time indicate that a programshould be saved longer, which delays expiration by a viewer-selectedinterval. The invention views the available storage for recordingprograms as a “cache”; unviewed programs are removed after a time, basedon the assumption they will not be watched if not watched soon afterrecording. Viewed programs become immediate candidates for deletion, onthe assumption they are no longer interesting.

With proper scheduling of recording and deletion of old programs, it ispossible to make a smaller storage area appear to be much larger, asthere is an ongoing flushing of old programs and addition of newprograms. Additionally, if resources are available, recordings may bescheduled of programs based on inferred preferences of the viewer; theseare called “fuzzy” recordings. This results in a system where theprogram storage area is always “full” of programming of interest to theviewer; no program is removed until another program is recorded in itsplace or the viewer explicitly deletes it.

Additionally, the viewer may select a program for recording at any time,and the recording window may conflict with other scheduled recordings,or there may not be sufficient space obtainable when the program must berecorded. The invention includes unique and novel methods of resolvingsuch conflicts.

Conflicts can arise for two reasons: lack of storage space, or lack ofinput sources. The television viewing system described herein includes afixed number of input sources for recording video and a storage medium,such as a magnetic disk, of finite capacity for storing the recordedvideo. Recording all television programs broadcast over any significantperiod of time is not possible. Therefore, resolving the conflicts thatarise because of resource limitations is the key to having the correctprograms available for viewing.

Referring again to FIG. 6, the invention maintains two schedules, theSpace Schedule 601 and the Input Schedule 602. The Space Schedule tracksall currently recorded programs and those which have been scheduled tobe recorded in the future. The amount of space available at any givenmoment in time may be found by generating the sum of all occupied space(or space that will be occupied at that time) and subtracting that fromthe total capacity available to store programs. Programs scheduled forrecording based on inferred preferences (“fuzzy” recordings) are notcounted in this calculation; such programs automatically lose allconflict decisions.

A program may be recorded 603 if at all times between when the recordingwould be initiated and when it expires, sufficient space is available tohold it. In addition, for the duration of the program, there must be aninput available from which to record it. The Input Schedule 602 tracksthe free and occupied time slots for each input source. In a preferredembodiment of the invention, the input sources may not be used foridentical services, e.g., one input may be from a digital televisionsignal and another from an analog television signal with differentprogramming. In this case, only those inputs from which the desiredprogram can be recorded are considered during scheduling.

With respect to FIG. 7, a flowchart is shown describing the steps takento schedule a recording in the preferred embodiment. First, an orderedlist of showings of the program of interest are generated 701. Althougha preferred embodiment of the invention orders these showings by time,such that the recording is made as soon as possible, any particularordering might be chosen. Each showing in this list 702 is then checkedto see if input 703 or space 704 conflicts occur as described above. Ifa showing is found with no conflicts, then the program is scheduled forrecording 705.

Otherwise, a preferred embodiment of the invention selects only thoseshowings of the program which have no input conflicts 706. Referringagain to FIG. 6, one can see that over the lifetime of a recording theamount of available space will vary as other programs are recorded orexpire. The list of showings is then sorted, preferably by the minimumamount of available space during the lifetime of the candidaterecording. Other orderings may be chosen.

Referring again to FIG. 7, for each candidate showing, the viewer ispresented with the option of shortening the expiration dates onconflicting programs 708, 709. This ordering results in the viewer beingpresented these choices in order from least impact on scheduled programsto greatest 707; there is no requirement of the invention that thisordering be used versus any other.

Should the viewer reject all opportunities to shorten expiration times,the final step involves selecting those showings with input conflicts710, and sorting these showings as in the first conflict resolutionphase 711. The viewer is then presented with the option to cancel eachpreviously scheduled recording in favor of the desired program 712, 713.Of course, the viewer may ultimately decide that nothing new will berecorded 714.

In a preferred embodiment of the invention, all conflicts are resolvedas early as possible, giving the viewer more control over what isrecorded. When the viewer makes an explicit selection of a program torecord, the algorithm described in FIG. 7 is used to immediatelyschedule the recording and manage any conflicts that arise.

Once an explicit selection has been made, and the viewer informed thatthe recording will be done, it will not be canceled without explicitapproval of the viewer.

Fuzzy recordings are periodically scheduled by a background task on theclient device. Given the prioritized list of preferred programs asdescribed earlier, the background scheduler attempts to schedule eachpreferred program in turn until the list is exhausted or no furtheropportunity to record is available. A preferred program is scheduled ifand only if there are no conflicts with other scheduled programs. Apreferred program which has been scheduled may be deleted under twoconditions: first, if it conflicts with an explicit selection, andsecond, if a change in viewer preferences identifies a higher priorityprogram that could be recorded at that time.

A further complication arises when handling aggregate viewing objectsfor which recording is requested. If conflict resolution was handledaccording to the method above for such objects, a potentially largenumber of conflicts might be generated, leading to a confusing andfrustrating experience for the viewer in resolving the conflicts. Thus,when aggregate objects are chosen for recording, conflicts areautomatically resolved in favor of the existing schedule.

In a preferred embodiment of the invention, conflicts resulting from therecording of aggregate objects will be resolved using the preferenceweighting of the programs involved; if multiple conflicts are caused bya particular program in the aggregate object, it will only be recordedif its preference exceeds that of all conflicting programs.

Methods Applied to Software Objects

The client system requires a complex software environment for properoperation. An operating system manages the interaction between hardwaredevices in the client and software applications which manipulate thosedevices. The television viewing object database is managed by a distinctsoftware application. The time-warping software application is yetanother application.

It is desirable to add new features or correct defects in these andother software subsystems which run on the client hardware device. Usingthe methods described herein, it is possible to replicate viewingobjects containing updated software modules into the client systemdatabase. Once present in the client system database, the followingunique and novel methods are used to install the updated software andcause the client system to begin executing the new software.

The software environment of the device is instantiated as a sequence ofsteps that occur when power is first applied to the device, each stepbuilding up state information which supports proper application of thefollowing step. The last step launches the applications which manage thedevice and interact with the viewer. These steps are:

-   1. A read-only or electrically programmable memory in the device    holds an initial bootstrap sequence of instructions. These    instructions initialize low-level parameters of the client device,    initialize the disk storage system, and load a bootstrap loader from    the disk into memory, to which execution is then passed. This    initial bootstrap may be changed if it resides in an electrically    programmable memory.-   2. The second stage boot loader then locates the operating system on    the disk drive, loads the operating system into memory, and passes    execution to the operating system. This loader must exist at a    specific location on the disk so as to be easily located by the    initial loader.

The operating system performs necessary hardware and softwareinitialization. It then loads the viewing object database software fromthe disk drive, and begins execution of the application. Otherapplication software, such as the time-warping software and viewerinteraction software, are also loaded and started. This software isusually located in a separate area on the disk from the object databaseor captured television programs.

Ideally, new software would be installed by simply copying it to theappropriate place on the disk drive and rebooting the device. Thisoperation is fraught with danger, especially in a home environment.Power may fail while copying the software, resulting in an inconsistentsoftware image and potential operating problems. The new software mayhave defects which prevent proper operation. A failure may occur on thedisk drive, corrupting the software image.

Although the methods of this invention have referred to a disk drive,one skilled in the art will readily appreciate that the methodsdescribed here apply generally to any persistent storage system. A diskdrive, and other persistent storage systems, are typically formattedinto a sequence of fixed-size blocks, called sectors. “Partitions” aresequential, non-overlapping subsets of this sequence which break up thestorage into logically independent areas.

With respect to FIG. 8, the invention maintains a sector of informationat a fixed location on the disk drive 803 called the “boot sector” 804.The boot sector 804 contains sufficient information for the initialbootstrap 801 to understand the partitioning of the drive 803, and tolocate the second stage boot loader 806.

The disk is partitioned into at least seven (7) partitions. There aretwo (2) small partitions dedicated to holding a copy of the second stageboot loader 806, two (2) partitions holding a copy of the operatingsystem kernel 807, two (2) partitions containing a copy of theapplication software 808, and a partition to be used as scratch memory809. For duplicated partitions, an indication is recorded in the bootsector 805 in which one of the partitions is marked “primary”, and thesecond is marked “backup”.

One skilled in the art will readily appreciate that, although twopartitions are described herein for redundancy, triple, quadruple orgreater degrees of redundancy can be achieved by creating moreduplicated partitions.

With respect to FIGS. 9 a and 9 b, on boot 901, the initial bootstrapcode reads the boot sector 902, scans the partition table and locatesthe “primary” partition for the second stage boot loader. It thenattempts to load this program into memory 903. If it fails 904, forinstance, due to a failure of the disk drive, the boot loader attemptsto load the program in the “backup” partition into memory 905. Whicheverattempt succeeds, the boot loader then passes control to the newlyloaded program, along with an indication of which partition the programwas loaded from 906.

Similarly, the second stage boot loader reads the partition table andlocates the “primary” operating system kernel 907. If the kernel can notbe loaded 908, the “backup” kernel is loaded instead 909. In any case,control is passed to the operating system along with an indication ofthe source partition, along with the passed source partition from above910.

Finally, the operating system locates the “primary” partition containingapplication software and attempts to load the initial application 911.If this fails 912, then the operating system locates the “backup”partition and loads the initial application from it 913. An indicationof the source partition is passed to the initial application, along withthe source partition information from the previous steps. At this point,application software takes over the client system and normal viewingmanagement behavior begins 914.

This sequence of operations provides a reasonable level of protectionfrom disk access errors. It also allows for a method which enables newsoftware at any of these levels to be installed and reliably broughtinto operation.

An “installer” viewing object in the object database is used to recordthe status of software installation attempts. It records the state ofthe partitions for each of the three levels above, including anindication that an attempt to install new software is underway 915. Thisoperation is reliable due to the transactional nature of the database.

Referring to FIG. 10, installing a new software image at any of thethree levels is handled as follows: the new software image is firstcopied into the appropriate backup partition 1001, and an indication ismade in the database that a software installation is underway 1002. Theprimary and backup partition indications in the partition table are thenswapped 1003, and the system rebooted 1004. Eventually, control will bepassed to the initial application.

Referring again to FIG. 9 b, the first task of this application is toupdate the installer object. For each level 921, 922, the applicationchecks if an installation was in process 916, 917, and verifies that thelevel was loaded off of the primary partition 918. If so, theinstallation at that level was successful, and the installer object isupdated to indicate success for that level 919. Otherwise, theapplication copies the backup partition for that level over the primarypartition and indicates failure in the installer object for that level920. Copying the partition insures that a backup copy of known goodsoftware for a level is kept available at all times.

In a preferred embodiment of the invention, finalization of theinstallation for the top application level of software may be delayeduntil all parts of the application environment have been successfullyloaded and started. This provides an additional level of assurance thatall parts of the application environment are working properly beforepermanently switching to the new software.

Methods Applied to Operations Status Objects

Operations status objects are a class of viewing object in whichinformation about the usage, performance and behavior of the clientsystem is recorded. These objects are collected by the central sitewhenever communication with the central site is established.

The following operations status indicators are recorded for latercollection along with a time stamp:

-   1. Viewer actions, primarily pressing buttons on a remote control    device, are recorded. Each “button press” is recorded along with the    current time, and any other contextual information, such as the    current viewer context. Post-processing of this object at the    central site results in a complete trace of viewer actions,    including the context in which each action is taken.-   2. Automatic actions, such as beginning or ending the recording of a    program, or choosing a program to record based on viewer    preferences, are recorded. In addition, deletion of captured    programs is recorded. Post-processing of this object at the central    site results in a complete trace of program capture actions taken by    the client system, including the programs residing in the persistent    store at any point in time.-   3. Software installation actions, including reception, installation,    and post-reboot results are recorded.-   4. Hardware exceptions of various kinds, including but not limited    to: power fail/restart, internal temperature profile of the device,    persistent storage access errors, memory parity errors and primary    partition failures.

Since all actions are recorded along with a time stamp, it is possibleto reconstruct the behavior of the client system using a lineartime-based ordering. This allows manual or automatic methods to operateon the ordered list of events to correlate actions and behaviors. Forinstance, if an expected automatic action does not occur soon afterrebooting with new software, it may be inferred that the new softwarewas defective.

Processing of Television Viewing Objects by Central Site Systems

Sources of Television Viewing Objects

A client system has a single source of television viewing objects: thecentral site. The central site object database has many sources oftelevision viewing objects:

-   1. Program guide information obtained from outside sources is    processed to produce a consistent set of program guide objects,    indicating “programs”, “showings”, “channels”, “networks” and other    related objects. This set of objects will have dependencies    (“channels” depend on “networks”, “showings” depend on “programs”)    and other interrelationships. When a complete, consistent set of    objects is ready, it is added to the database as an atomic    operation.-   2. New software, including new applications or revisions of existing    software, are first packaged into “software” viewing objects. As    above, the software may have interdependencies, such as an    application depending on a dynamically loaded library, which must be    reflected in the interrelationships of the software objects    involved. In another example, there may be two types of client    systems in use, each of which requires different software objects;    these software objects must have attributes present indicating the    type of system they are targeted at. Once a consistent set of    objects is available, it is added to the database as an atomic    operation.-   3. Each client system has a unique, secret key embedded within it.    The public key matching this secret key is loaded into a “client”    management object, along with other interesting information about    the client, such as client type, amount of storage in the system,    etc. These objects are used to generate authentication objects as    necessary.-   4. Aggregation program guide objects are added in a similar fashion.    In this case, however, the aggregation object must refer to    primitive program guide objects already present in the database.    Also attached to the aggregation object are other objects, such as a    textual description, a screen-based icon, and other informational    attributes. Once a consistent set of ancillary objects to the    aggregation is available, it is added to the database as an atomic    operation.-   5. Data collected from client systems.

It should be clear that there may be any number of sources of viewingobjects, and this enumeration simply shows the most basic possiblesources.

Operations on Television Viewing Objects

There are a large number of possible operations on the centraltelevision viewing object database. The following examples are meant toshow the type of processing that may be performed, however the potentialoperations are not limited to these examples:

-   1. Using various viewing objects, a number of interesting    statistical analysis tasks may be performed:    -   1.1. By examining large numbers of uploaded operations status        objects, it is possible to perform extensive analysis of        hardware reliability trends and failure modes. For instance, it        is possible to correlate internal temperature with expected MTBF        (Mean Time Between Failures) of client devices.    -   1.2. By examining large numbers of uploaded viewing information,        it is possible to derive demographic or psychographic        information about various populations of client devices. For        example, it is possible to correlate TV programs most watched        within specific zip codes in which the client devices reside.    -   1.3. Similarly, by examining large numbers of viewing        information objects, it is possible to generate “rating” and        “share” values for particular programs with fully automated        methods, unlike existing program rating methods.    -   1.4. There are many other examples of statistical analysis tasks        that might be performed on the viewing object database; these        examples are not meant to limit the applicability of the        invention, but to illustrate by example the spectrum of        operations that might be performed.-   2. Specialty aggregation objects may be automatically generated    based on one or more attributes of all available viewing objects.-    Such generation is typically performed by first extracting    information of interest from each viewing object, such as program    description, actor, director, etc., and constructing a simple table    of programs and attributes. An aggregate viewing object is then    generated by choosing one or more attributes, and adding to the    aggregate those programs for which the chosen attributes match in    some way.-    These objects are then included in the slices generated for    transmission, possibly based on geographic or other information.    Some example aggregates that might be created are:    -   2.1. Aggregates based on events, such as a major league football        game in a large city. In this case, all programs viewable by        client devices in or around that city are collected, and the        program description searched for the names of the teams playing,        coaches names, major player's names, the name of the ballpark,        etc. Matching program objects are added to the aggregate, which        is then sliced for transmission only to client devices in        regions in and around the city.    -   2.2. Aggregates based on persons of common interest to a large        number of viewers. For instance, an aggregate might be        constructed of all “John Wayne” movies to be broadcast in the        next week.    -   2.3. Aggregates based on viewing behavior can be produced. In        this case, uploaded viewing objects are scanned for elements of        common interest, such as types of programs viewed, actual        programs viewed, etc. For example, a “top ten list” aggregate of        programs viewed on all client devices in the last week might be        generated containing the following week's showing of those        programs.    -   2.4. Aggregates based on explicit selections by viewers. During        viewing of a program, the viewer might be presented with an        opportunity to “vote” on the current program, perhaps on the        basis of four perceived attributes (storyline, acting,        directing, cinematography), which generates viewing objects that        are uploaded later. These votes are then scanned to determine an        overall rating of the program, which is transmitted to those who        voted for their perusal.    -   2.5. There are many other examples of how the basic facilities        of this invention allow the service operator to provide        pre-sorted and pre-selected groups of related programs to the        user of the client device for perusal and selection. These        examples are not meant to limit the applicability of the        invention, but to illustrate by example the spectrum of        operations that might be performed.-   3. Manual methods may also be used to generate aggregate objects, a    process sometimes called “authoring”. In this case, the person    creating the aggregate chooses programs for explicit addition to the    aggregate. It is then transmitted in the same manner as above.

Clearly, aggregation program objects may also permit the expression ofpreferences or recording of other information. These results may beuploaded to the central site to form a basis for the next round ofaggregate generation or statistical analysis, and so on.

This feedback loop closes the circuit between service provider and theuniverse of viewers using the client device. This unique and novelapproach provides a new form of television viewing by providing uniqueand compelling ways for the service provider to present and promote theviewing of television programs of interest to individuals whilemaintaining reliable and consistent operation of the service.

Remote Client System Control

Many in-home consumer electronics devices already contain mass storage,with many more to come. The amount of storage available in these devicesis already staggering, and there is no end in sight to the “double eachyear” rule-of-thumb for disk drives. Other types of storage media arealso getting fatter every year, including: CompactFlash, SmartMedia,Zip, Flash Memory Sticks, MicroDrive, PocketDrive, and SuperDisk.

The obvious control of this storage is by the consumer, storing theirown TV shows, music, pictures, etc. A less obvious use, but one thatwill continue to grow in application and importance, is aservice-provider's control of this storage. There will be a continuallygrowing desire for a service provider to have control over storage thatis physically possessed by the consumer.

Referring to FIG. 11, the invention's distribution/telephony servers1101 have the ability to send objects to client systems 1103, 1104,1105, that command the client system to perform a function, e.g., recorda specific program from a broadcaster 1102 or capture content that theservice directs the client system to capture. Every function that a usercan control in addition to maintenance and control aspects of a clientsystem are encompassed in a set of objects called capture requests.

Client systems 1103, 1104, 1105, have the ability to capture and recordany type of multimedia material (TV shows, movies, advertisements,product and service offerings, music, radio, audio, ebooks, etc.) thatis transmitted across a broadcast or communications link.

Capture request objects are sent from the distribution/telephony servers1101 to individual or groups of client systems 1103, 1104, 1105. Thefollowing are some examples of the power of capture requests:

-   -   Capture requests allow the invention's service to schedule        recordings on client systems. These recordings can be for video        or data content.    -   Capture requests specify the recordings using program names and        optionally an

Affiliate, e.g., NBC. Specifying an affiliate limits the recordings tothe specified affiliate's stations. If the program is shown on anotheraffiliate's station, it is not recorded.

-   -   Capture requests have the ability to schedule single recordings        or schedule recordings of all of the showings of a series.    -   Capture requests have the ability to set attributes of the        resulting recordings:        -   Recording disk location—If the recording will occupy the            user's disk space on the client system or the client            system's hidden space on the disk (storage device).        -   Recording tuner priority—Whether these recordings will cause            other programs to not be recorded because of tuner conflicts            (on client systems having multiple input tuners).        -   Recording keep time—The suggested minimum length of time            that a recording should remain on the client system's disk            before other recordings should delete it.        -   Recording quality—The recording quality of the recording,            e.g., low, good, high, best.    -   Capture requests have the ability to create a season pass for a        program series. A season pass will record every showing of a        program on a specified channel.    -   Capture requests can specify an expiration date. This date is        used to determine the date, after which, recordings are not        scheduled. Also after the expiration date, the capture requests        are removed from the client system's disk.    -   The invention's service has the ability to modify a capture        request, and the client system will reschedule all of the        recordings from the previous capture request with the new        options.    -   The invention's service has the ability to target specific        client systems to receive a particular capture request. This        allows the invention to schedule recordings on a subset of all        of client systems.

With respect to FIG. 12, the mechanism and process for remote-control ofstorage on client systems can be segmented functionally into threeparts:

-   -   Front-End Service 1201: This part is where capture requests get        created using authoring tools, where they are previewed, and how        they are distributed to client devices 1205. This is also where        decisions about how the client-side storage is allocated        (partitioned) and may be authored and changed over time. The        policy for how the storage gets used is authored here at the        front end.    -   Client system 1205: The client system 1205 is responsible for        implementing the storage partition as directed by the service,        for capturing media or objects per capture requests, and for        implementing the rotation and expiration mechanisms. The client        itself holds no policy about how the storage gets used; it        simply implements a generic mechanism and the policy is given by        the service 1201.    -   Back-End Service 1206: Client systems 1205 may report back the        success or failure of requests by the service 1201, how received        data/media is used, or may even send back data/media which is        redistributed via the distribution service 1202, 1203, 1204        (e.g. picture, video, music sharing services).        Transparent “Pull” that Looks and Feels Like “Push”

To the client system 1205, this looks like the service “pushed” content(data, media, whatever) down. In actuality, the service merely directedthe client device to pull content, or to capture it. This is transparentto the user of the client system 1205.

Remote Authoring of Capture Requests

Users of the client system 1205 expect to be able to have full controlover the content stored on the client system 1205, e.g., telling theclient system 1205 what to capture and when to capture the content, whento delete content, etc. The capture request mechanism gives this samelevel of control to the remote author.

The authoring tool 1201 allows the author to create a capture requestobject. The schema for this object defines metadata that specifies:

-   -   Where the data/media is to be captured (in the form of a        station/channel, URL, or any other pointer to available media).    -   When the data/media is to be captured (in the case of broadcast        or multicast content).    -   Priority of the capture request—How important it is for the        client system to preempt other activities in order to perform        this request.    -   Priority of the content—If local storage is unavailable, what        other content should be displaced to make room.    -   Presentation of content—How in the client system/user-experience        should this content be presented (rotation policy, display        policy, expiration, view once/many, eligibility, etc.).    -   Client-side targeting—The request can include any number of        criteria that must be met in order for the request to be valid.        For example, the request might say “only execute on clients that        have these capabilities” or “only execute on clients that        already have this content available.” The capabilities can be        described using an arbitrarily sophisticated query mechanism.        Remote Control of Space Allocation

In many cases, it is desirable to partition the storage on the clientsystem such that some of the storage is left under the total control ofthe user and some of the storage is under total control of the service.

The invention allows this partitioning to be changed at any time by theservice. This is useful in allowing for changes in policy in the future(e.g., to give some space back to the user, or take some away) or toaccount for new storage configurations (e.g., when new, biggerconfigurations or upgrades become available).

The mechanism allows an author at the service to create a “PartitionTable” which specifies how much storage should be allocated based onsize of storage and particular client configuration.

Control of which Clients Receive which Capture Requests

When capture requests are distributed via the service 1202, 1203, 1204,the distribution service 1203 controls which client systems receive thecapture requests.

Service-side tools allow specification by serial number, by clientcapability, by client service tier, etc. A table is maintained whichputs each client device into one or more capture request groups. A givencapture request can then be assigned to one or more of these groups.

Mechanism Separated from Policy

Note that this entire system is designed to keep policy out of theclient system. All policy is determined by the author or automaticallyby the service. The client system merely executes directives or requestsfrom the service.

Applications of Remote-Controlled Storage

Remotely controlling the storage on a client system is useful in manyapplication such as:

-   -   Promotions    -   Mall    -   Cineplex    -   Music    -   Pictures    -   Video on Demand    -   Software    -   Games    -   Personal News, Weather, Sports . . . .        Varieties of Remote-Controlled Storage

Remote-controlled storage can take on many forms:

-   -   Disk Drives vs. All Storage Mediums: Although hard disk drives        are the obvious application of remote-controlled storage, other        mediums would work equally well. A music service could “push”        promotional music onto a personal music device every time the        device is hot synced.    -   Always On vs. Sometimes On vs. Rarely On: This mechanism applies        equally well to systems that are always connected to the service        (e.g., with an always-on internet connection), client systems        that connect to the service periodically (e.g., nightly connect        via phone line), and those systems that only rarely connect        (e.g., when a PDA or camera is hot-synced).

Although the invention is described herein with reference to thepreferred embodiment, one skilled in the art will readily appreciatethat other applications may be substituted for those set forth hereinwithout departing from the spirit and scope of the present invention.Accordingly, the invention should only be limited by the Claims includedbelow.

The invention claimed is:
 1. A method, comprising: receiving a capturerequest from a server on a client system, the capture requestinstructing the client system to record a first multimedia content froma first source of one or more sources across a network; receiving arecording request from a local user on the client system, the recordingrequest instructing the client system to record a second multimediacontent from a second source of the one or more sources across thenetwork; autonomously scheduling, by the client system, capture requestrecordings and recording request recordings for recording multimediacontent from the one or more sources across the network on at least onestorage device.
 2. The method of claim 1, wherein the capture requestand the recording request each instruct the client system of a differentURL to record requested multimedia content from.
 3. The method of claim1, wherein the multimedia content is video or data content.
 4. Themethod of claim 1, wherein the capture request and the recording requesteach specify a different recording quality setting for recording.
 5. Themethod of claim 1, wherein the server targets specific client systems toreceive a particular capture request.
 6. The method of claim 1, whereinthe capture request specifies a content priority attribute indicating apriority for storing the second multimedia content relative to othermedia content.
 7. The method of claim 1, further comprising the clientsystem storing capture request recordings in a different storage spacethan recording request recordings.
 8. An apparatus, comprising: asubsystem, implemented at least partially in hardware, on a clientsystem that receives a capture request from a server, the capturerequest instructing the client system to record a first multimediacontent from a first source of one or more sources across a network; asubsystem, implemented at least partially in hardware, on the clientsystem that receives a recording request from a local user on the clientsystem, the recording request instructing the client system to record asecond multimedia content from a second source of the one or moresources across the network; a subsystem, implemented at least partiallyin hardware, on the client system that autonomously schedules capturerequest recordings and recording request recordings for recordingmultimedia content from one or more sources across the network on atleast one storage device.
 9. The apparatus of claim 8, wherein thecapture request and the recording request each instruct the clientsystem of a different URL to record requested multimedia content from.10. The apparatus of claim 8, wherein the multimedia content is video ordata content.
 11. The apparatus of claim 8, wherein the capture requestand the recording request each specify a different recording qualitysetting for recording.
 12. The apparatus of claim 8, wherein the serveris configured to targets specific client systems to receive a particularcapture request.
 13. The apparatus of claim 8, wherein the capturerequest specifies a content priority attribute indicating a priority forstoring the second multimedia content relative to other media content.14. The apparatus of claim 8, wherein the client system stores capturerequest recordings in a different storage space than recording requestrecordings.
 15. A non-transitory computer-readable medium storing one ormore sequences of instructions, which instructions, when executed by oneor more processors, cause the one or more processors to perform a methodcomprising: receiving a capture request from a server on a clientsystem, the capture request instructing the client system to record afirst multimedia content from a first source of one or more sourcesacross a network; receiving a recording request from a local user on theclient system, the recording request instructing the client system torecord a second multimedia content from a second source of the one ormore sources across the network; autonomously scheduling, by the clientsystem, capture request recordings and recording request recordings forrecording multimedia content from one or more sources across the networkon at least one storage device.
 16. The non-transitory computer-readablemedium of claim 15, wherein the capture request and the recordingrequest each instruct the client system of a different URL to recordrequested multimedia content from.
 17. The non-transitorycomputer-readable medium of claim 15, wherein the multimedia content isvideo or data content.
 18. The non-transitory computer-readable mediumof claim 15, wherein the capture request and the recording request eachspecify a different recording quality setting for recording.
 19. Thenon-transitory computer-readable medium of claim 15, wherein the servertargets specific client systems to receive a particular capture request.20. The non-transitory computer-readable medium of claim 15, wherein thecapture request specifies a content priority attribute indicating apriority for storing the second multimedia content relative to othermedia content.
 21. The non-transitory computer-readable medium of claim15, further comprising the client system storing capture requestrecordings in a different storage space than recording requestrecordings.